home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / styles / CSSStyleDeclaration.as next >
Encoding:
Text File  |  2008-10-29  |  9.2 KB  |  336 lines
  1. package mx.styles
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.Dictionary;
  6.    import mx.core.Singleton;
  7.    import mx.core.mx_internal;
  8.    import mx.managers.SystemManagerGlobals;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class CSSStyleDeclaration extends EventDispatcher
  13.    {
  14.       mx_internal static const VERSION:String = "3.0.0.0";
  15.       
  16.       private static const NOT_A_COLOR:uint = 4294967295;
  17.       
  18.       private static const FILTERMAP_PROP:String = "__reserved__filterMap";
  19.       
  20.       mx_internal var effects:Array;
  21.       
  22.       protected var overrides:Object;
  23.       
  24.       public var defaultFactory:Function;
  25.       
  26.       public var factory:Function;
  27.       
  28.       mx_internal var selectorRefCount:int = 0;
  29.       
  30.       private var styleManager:IStyleManager2;
  31.       
  32.       private var clones:Dictionary;
  33.       
  34.       public function CSSStyleDeclaration(param1:String = null)
  35.       {
  36.          clones = new Dictionary(true);
  37.          super();
  38.          if(param1)
  39.          {
  40.             styleManager = Singleton.getInstance("mx.styles::IStyleManager2") as IStyleManager2;
  41.             styleManager.setStyleDeclaration(param1,this,false);
  42.          }
  43.       }
  44.       
  45.       mx_internal function addStyleToProtoChain(param1:Object, param2:DisplayObject, param3:Object = null) : Object
  46.       {
  47.          var p:String = null;
  48.          var emptyObjectFactory:Function = null;
  49.          var filteredChain:Object = null;
  50.          var filterObjectFactory:Function = null;
  51.          var i:String = null;
  52.          var chain:Object = param1;
  53.          var target:DisplayObject = param2;
  54.          var filterMap:Object = param3;
  55.          var nodeAddedToChain:Boolean = false;
  56.          var originalChain:Object = chain;
  57.          if(filterMap)
  58.          {
  59.             chain = {};
  60.          }
  61.          if(defaultFactory != null)
  62.          {
  63.             defaultFactory.prototype = chain;
  64.             chain = new defaultFactory();
  65.             nodeAddedToChain = true;
  66.          }
  67.          if(factory != null)
  68.          {
  69.             factory.prototype = chain;
  70.             chain = new factory();
  71.             nodeAddedToChain = true;
  72.          }
  73.          if(overrides)
  74.          {
  75.             if(defaultFactory == null && factory == null)
  76.             {
  77.                emptyObjectFactory = function():void
  78.                {
  79.                };
  80.                emptyObjectFactory.prototype = chain;
  81.                chain = new emptyObjectFactory();
  82.                nodeAddedToChain = true;
  83.             }
  84.             for(p in overrides)
  85.             {
  86.                if(overrides[p] === undefined)
  87.                {
  88.                   delete chain[p];
  89.                }
  90.                else
  91.                {
  92.                   chain[p] = overrides[p];
  93.                }
  94.             }
  95.          }
  96.          if(filterMap)
  97.          {
  98.             if(nodeAddedToChain)
  99.             {
  100.                filteredChain = {};
  101.                filterObjectFactory = function():void
  102.                {
  103.                };
  104.                filterObjectFactory.prototype = originalChain;
  105.                filteredChain = new filterObjectFactory();
  106.                for(i in chain)
  107.                {
  108.                   if(filterMap[i] != null)
  109.                   {
  110.                      filteredChain[filterMap[i]] = chain[i];
  111.                   }
  112.                }
  113.                chain = filteredChain;
  114.                chain[FILTERMAP_PROP] = filterMap;
  115.             }
  116.             else
  117.             {
  118.                chain = originalChain;
  119.             }
  120.          }
  121.          if(nodeAddedToChain)
  122.          {
  123.             clones[chain] = 1;
  124.          }
  125.          return chain;
  126.       }
  127.       
  128.       public function getStyle(param1:String) : *
  129.       {
  130.          var _loc2_:* = undefined;
  131.          var _loc3_:* = undefined;
  132.          if(overrides)
  133.          {
  134.             if(param1 in overrides && overrides[param1] === undefined)
  135.             {
  136.                return undefined;
  137.             }
  138.             _loc3_ = overrides[param1];
  139.             if(_loc3_ !== undefined)
  140.             {
  141.                return _loc3_;
  142.             }
  143.          }
  144.          if(factory != null)
  145.          {
  146.             factory.prototype = {};
  147.             _loc2_ = new factory();
  148.             _loc3_ = _loc2_[param1];
  149.             if(_loc3_ !== undefined)
  150.             {
  151.                return _loc3_;
  152.             }
  153.          }
  154.          if(defaultFactory != null)
  155.          {
  156.             defaultFactory.prototype = {};
  157.             _loc2_ = new defaultFactory();
  158.             _loc3_ = _loc2_[param1];
  159.             if(_loc3_ !== undefined)
  160.             {
  161.                return _loc3_;
  162.             }
  163.          }
  164.          return undefined;
  165.       }
  166.       
  167.       public function clearStyle(param1:String) : void
  168.       {
  169.          setStyle(param1,undefined);
  170.       }
  171.       
  172.       public function setStyle(param1:String, param2:*) : void
  173.       {
  174.          var _loc7_:int = 0;
  175.          var _loc8_:Object = null;
  176.          var _loc3_:Object = getStyle(param1);
  177.          var _loc4_:Boolean = false;
  178.          if(mx_internal::selectorRefCount > 0 && factory == null && defaultFactory == null && !overrides && _loc3_ !== param2)
  179.          {
  180.             _loc4_ = true;
  181.          }
  182.          if(param2 !== undefined)
  183.          {
  184.             mx_internal::setStyle(param1,param2);
  185.          }
  186.          else
  187.          {
  188.             if(param2 == _loc3_)
  189.             {
  190.                return;
  191.             }
  192.             mx_internal::setStyle(param1,param2);
  193.          }
  194.          var _loc5_:Array = SystemManagerGlobals.topLevelSystemManagers;
  195.          var _loc6_:int = int(_loc5_.length);
  196.          if(_loc4_)
  197.          {
  198.             _loc7_ = 0;
  199.             while(_loc7_ < _loc6_)
  200.             {
  201.                _loc8_ = _loc5_[_loc7_];
  202.                _loc8_.regenerateStyleCache(true);
  203.                _loc7_++;
  204.             }
  205.          }
  206.          _loc7_ = 0;
  207.          while(_loc7_ < _loc6_)
  208.          {
  209.             _loc8_ = _loc5_[_loc7_];
  210.             _loc8_.notifyStyleChangeInChildren(param1,true);
  211.             _loc7_++;
  212.          }
  213.       }
  214.       
  215.       private function clearStyleAttr(param1:String) : void
  216.       {
  217.          var _loc2_:* = undefined;
  218.          if(!overrides)
  219.          {
  220.             overrides = {};
  221.          }
  222.          overrides[param1] = undefined;
  223.          for(_loc2_ in clones)
  224.          {
  225.             delete _loc2_[param1];
  226.          }
  227.       }
  228.       
  229.       mx_internal function createProtoChainRoot() : Object
  230.       {
  231.          var _loc1_:Object = {};
  232.          if(defaultFactory != null)
  233.          {
  234.             defaultFactory.prototype = _loc1_;
  235.             _loc1_ = new defaultFactory();
  236.          }
  237.          if(factory != null)
  238.          {
  239.             factory.prototype = _loc1_;
  240.             _loc1_ = new factory();
  241.          }
  242.          clones[_loc1_] = 1;
  243.          return _loc1_;
  244.       }
  245.       
  246.       mx_internal function clearOverride(param1:String) : void
  247.       {
  248.          if(Boolean(overrides) && Boolean(overrides[param1]))
  249.          {
  250.             delete overrides[param1];
  251.          }
  252.       }
  253.       
  254.       mx_internal function setStyle(param1:String, param2:*) : void
  255.       {
  256.          var _loc3_:Object = null;
  257.          var _loc4_:* = undefined;
  258.          var _loc5_:Number = NaN;
  259.          var _loc6_:Object = null;
  260.          if(param2 === undefined)
  261.          {
  262.             clearStyleAttr(param1);
  263.             return;
  264.          }
  265.          if(param2 is String)
  266.          {
  267.             if(!styleManager)
  268.             {
  269.                styleManager = Singleton.getInstance("mx.styles::IStyleManager2") as IStyleManager2;
  270.             }
  271.             _loc5_ = Number(styleManager.getColorName(param2));
  272.             if(_loc5_ != NOT_A_COLOR)
  273.             {
  274.                param2 = _loc5_;
  275.             }
  276.          }
  277.          if(defaultFactory != null)
  278.          {
  279.             _loc3_ = new defaultFactory();
  280.             if(_loc3_[param1] !== param2)
  281.             {
  282.                if(!overrides)
  283.                {
  284.                   overrides = {};
  285.                }
  286.                overrides[param1] = param2;
  287.             }
  288.             else if(overrides)
  289.             {
  290.                delete overrides[param1];
  291.             }
  292.          }
  293.          if(factory != null)
  294.          {
  295.             _loc3_ = new factory();
  296.             if(_loc3_[param1] !== param2)
  297.             {
  298.                if(!overrides)
  299.                {
  300.                   overrides = {};
  301.                }
  302.                overrides[param1] = param2;
  303.             }
  304.             else if(overrides)
  305.             {
  306.                delete overrides[param1];
  307.             }
  308.          }
  309.          if(defaultFactory == null && factory == null)
  310.          {
  311.             if(!overrides)
  312.             {
  313.                overrides = {};
  314.             }
  315.             overrides[param1] = param2;
  316.          }
  317.          for(_loc4_ in clones)
  318.          {
  319.             _loc6_ = _loc4_[FILTERMAP_PROP];
  320.             if(_loc6_)
  321.             {
  322.                if(_loc6_[param1] != null)
  323.                {
  324.                   _loc4_[_loc6_[param1]] = param2;
  325.                }
  326.             }
  327.             else
  328.             {
  329.                _loc4_[param1] = param2;
  330.             }
  331.          }
  332.       }
  333.    }
  334. }
  335.  
  336.